home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / util / gnu / gnu_oleo_1_2_2.lha / oleo-1.2.2 / parse.tab.c < prev    next >
C/C++ Source or Header  |  1993-03-03  |  46KB  |  1,574 lines
  1. #ifndef lint
  2. char yysccsid[] = "@(#)yaccpar    1.5 (Berkeley) 06/03/90";
  3. #endif
  4. #line 2 "parse.y"
  5. /*    Copyright (C) 1990, 1992, 1993 Free Software Foundation, Inc.
  6.  
  7. This file is part of Oleo, the GNU Spreadsheet.
  8.  
  9. Oleo is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2, or (at your option)
  12. any later version.
  13.  
  14. Oleo is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with Oleo; see the file COPYING.  If not, write to
  21. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22. #line 42 "parse.y"
  23. #include "funcdef.h"
  24.  
  25. #include <ctype.h>
  26.  
  27. #define obstack_chunk_alloc ck_malloc
  28. #define obstack_chunk_free free
  29. #include "obstack.h"
  30. #include "sysdef.h"
  31.  
  32. #include "global.h"
  33. #include "errors.h"
  34. #include "node.h"
  35. #include "eval.h"
  36. #include "ref.h"
  37.  
  38. int yylex ();
  39. #ifdef __STDC__
  40. void yyerror (char *);
  41. #else
  42. void yyerror ();
  43. #endif
  44. VOIDSTAR parse_hash;
  45. extern VOIDSTAR hash_find();
  46.  
  47. /* This table contains a list of the infix single-char functions */
  48. unsigned char fnin[] = {
  49.     SUM, DIFF, DIV, PROD, MOD, /* AND, OR, */ POW, EQUAL, IF, CONCAT, 0
  50. };
  51.  
  52. #define YYSTYPE _y_y_s_t_y_p_e
  53. typedef struct node *YYSTYPE;
  54. YYSTYPE parse_return;
  55. #ifdef __STDC__
  56. YYSTYPE make_list (YYSTYPE, YYSTYPE);
  57. #else
  58. YYSTYPE make_list ();
  59. #endif
  60.  
  61. char *instr;
  62. int parse_error = 0;
  63. extern struct obstack tmp_mem;
  64.  
  65. #line 66 "y.tab.c"
  66. #define NE 257
  67. #define LE 258
  68. #define GE 259
  69. #define NEG 260
  70. #define L_CELL 261
  71. #define L_RANGE 262
  72. #define L_VAR 263
  73. #define L_CONST 264
  74. #define L_FN0 265
  75. #define L_FN1 266
  76. #define L_FN2 267
  77. #define L_FN3 268
  78. #define L_FN4 269
  79. #define L_FNN 270
  80. #define L_FN1R 271
  81. #define L_FN2R 272
  82. #define L_FN3R 273
  83. #define L_FN4R 274
  84. #define L_FNNR 275
  85. #define L_LE 276
  86. #define L_NE 277
  87. #define L_GE 278
  88. #define YYERRCODE 256
  89. short yylhs[] = {                                        -1,
  90.     0,    0,    1,    1,    1,    1,    1,    1,    1,    1,
  91.     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  92.     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  93.     1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
  94.     5,    5,    4,    4,    2,    2,
  95. };
  96. short yylen[] = {                                         2,
  97.     1,    1,    1,    1,    3,    4,    6,    8,   10,    4,
  98.     4,    4,    6,    6,    8,    8,    8,    8,    4,    5,
  99.     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  100.     3,    3,    3,    2,    2,    3,    3,    2,    1,    3,
  101.     1,    1,    1,    3,    1,    1,
  102. };
  103. short yydefred[] = {                                      0,
  104.     2,    0,    0,   45,   46,    3,    0,    0,    0,    0,
  105.     0,    0,    0,    0,    0,    0,    0,    0,    0,    4,
  106.    34,   35,    0,    0,    0,    0,    0,    0,    0,    0,
  107.     0,    0,   38,    0,    0,    0,    0,    0,    0,    0,
  108.     0,    0,    0,    0,    0,    0,    0,    0,    5,    0,
  109.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  110.     0,   41,    0,    0,   43,   37,   36,    0,    0,    0,
  111.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  112.     0,    6,    0,    0,    0,   10,    0,   11,   12,    0,
  113.     0,    0,    0,   19,    0,    0,    0,    0,    0,    0,
  114.     0,    0,    0,    0,   44,    0,    7,    0,    0,   13,
  115.     0,   14,    0,    0,    0,    0,    0,    0,    0,    0,
  116.     0,    8,    0,   15,   16,   17,   18,    0,    9,
  117. };
  118. short yydgoto[] = {                                      18,
  119.    63,   20,   55,   64,   65,
  120. };
  121. short yysindex[] = {                                    -33,
  122.     0,  208,  208,    0,    0,    0,  -36,  -30,  -22,  -14,
  123.    -9,   -8,   -7,   -6,   -5,   -4,  160,    0,  943,    0,
  124.     0,    0,    6,  208,  208,  208,  208,  208, -254, -248,
  125.  -233,  176,    0,  240,  208,  208,  208,  208,  208,  208,
  126.   208,  208,  208,  208,  208,  208,  208,  208,    0,  474,
  127.   485,  515,  543,  943,  -39,    8,   12,   -3,   21,   26,
  128.    36,    0,  943,  -38,    0,    0,    0,  554,  970,  981,
  129.   981,  -26,  -26,  -26,  -26,  157,  157,  -57,  -57,  -57,
  130.   -57,    0,  208,  208,  208,    0,  208,    0,    0,  208,
  131.   208,  208,  208,    0,  176,  208,  581,  608,  619,  943,
  132.   315,  447,  647,  674,    0,  943,    0,  208,  208,    0,
  133.   208,    0,  208,  208,  208,  715,  743,  781,  808,  847,
  134.   874,    0,  208,    0,    0,    0,    0,  901,    0,
  135. };
  136. short yyrindex[] = {                                      0,
  137.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  138.     0,    0,    0,    0,    0,    0,    0,    0,   92,    0,
  139.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  140.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  141.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  142.     0,    0,    0,  -21,    0,    0,    0,    0,    0,    0,
  143.     0,    0,  -19,    0,    0,    0,    0,    0,   28,  118,
  144.   145,   67,  116,  127,  134,   79,   88,    1,   13,   40,
  145.    52,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  146.     0,    0,    0,    0,    0,    0,    0,    0,    0,  -17,
  147.     0,    0,    0,    0,    0,  143,    0,    0,    0,    0,
  148.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  149.     0,    0,    0,    0,    0,    0,    0,    0,    0,
  150. };
  151. short yygindex[] = {                                      0,
  152.  1053,    0,    0,    0,    9,
  153. };
  154. #define YYTABLESIZE 1240
  155. short yytable[] = {                                       3,
  156.    30,   86,   94,   23,   87,   95,   17,   56,   57,   24,
  157.    47,    2,   31,   58,   59,   45,   43,   25,   44,   39,
  158.    46,   42,   39,   40,   42,   26,   40,   21,   60,   61,
  159.    27,   28,   29,   30,   31,   32,   48,   30,   30,   32,
  160.    90,   30,   30,   30,   30,   30,   49,   30,   88,   31,
  161.    31,   33,   89,   31,   31,   31,   31,   31,   30,   31,
  162.    30,   30,   30,   30,   91,   21,   22,   48,   21,   92,
  163.    31,   21,   31,   31,   31,   31,   32,   32,   28,   93,
  164.    32,   32,   32,   32,   32,   21,   32,   29,   33,   33,
  165.    21,    1,   33,   33,   33,   33,   33,   32,   33,   32,
  166.    32,   32,   32,  105,   22,    0,    0,   22,    0,   33,
  167.    22,   33,   33,   33,   33,   23,   28,   24,    0,   28,
  168.     0,   28,   28,   28,   22,   29,   26,   22,   29,   22,
  169.    29,   29,   29,   27,    0,    0,   28,    0,   28,   28,
  170.    28,   28,   20,    0,   25,   29,    0,   29,   29,   29,
  171.    29,    0,    0,   23,    0,   24,   23,    0,   24,   23,
  172.     0,   24,    0,    0,   26,    0,    0,   26,    0,    0,
  173.    26,   27,    0,   23,   27,   24,   23,   27,   23,    0,
  174.    24,    0,   25,   20,   26,   25,   20,   26,   25,   26,
  175.     0,   27,    3,   47,   27,    0,   27,    0,   45,   17,
  176.    20,    0,   25,   46,    2,    0,    0,   25,    3,    0,
  177.     0,    0,    0,    0,    0,   17,    0,    0,    0,    0,
  178.     2,    0,    1,    0,    0,    0,    0,    4,    0,    5,
  179.     6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
  180.     3,   16,    0,    0,    0,    0,    0,   17,    0,    0,
  181.    48,    0,    2,    0,    0,    0,   30,   30,   30,   30,
  182.     0,    0,    0,    0,    0,    0,    0,    0,   31,   31,
  183.    31,   31,    0,    0,    0,    0,   47,   36,    0,    0,
  184.    67,   45,   43,   21,   44,    0,   46,    0,    0,    0,
  185.     0,    0,    0,    0,    0,   32,   32,   32,   32,   39,
  186.    37,   41,   35,    0,    0,    0,    0,   33,   33,   33,
  187.    33,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  188.     0,    0,   22,   22,    0,    0,    0,    0,    0,    0,
  189.     0,    0,    0,   48,   28,   28,   28,   28,    0,    0,
  190.     0,    0,    0,   29,   29,   29,   29,    0,    0,    0,
  191.     0,   47,   36,    0,    0,  110,   45,   43,  111,   44,
  192.     0,   46,    0,    0,    0,    0,    0,    0,    0,    0,
  193.     0,   23,   23,   24,   39,   37,   41,   35,    0,    0,
  194.     0,    0,   26,   26,    0,    0,    0,    0,    0,   27,
  195.    27,    0,    0,    0,    0,    0,    0,    0,   20,    0,
  196.    25,    0,    0,    0,    0,    0,    0,    0,   48,    0,
  197.     0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
  198.     4,    0,    5,    6,    7,    8,    9,   10,   11,   12,
  199.    13,   14,   15,    0,   16,    0,    4,   62,    5,    6,
  200.     7,    8,    9,   10,   11,   12,   13,   14,   15,    0,
  201.    16,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  202.     0,    0,    0,    0,    0,    0,    0,    0,    4,    0,
  203.     5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
  204.    15,    0,   16,   47,   36,    0,    0,  112,   45,   43,
  205.   113,   44,    0,   46,    0,   66,   38,   40,   42,    0,
  206.     0,    0,    0,    0,    0,    0,   39,   37,   41,   35,
  207.    47,   36,    0,    0,   82,   45,   43,    0,   44,    0,
  208.    46,   47,   36,    0,    0,    0,   45,   43,   83,   44,
  209.     0,   46,    0,   39,   37,   41,   35,    0,    0,    0,
  210.    48,    0,    0,    0,   39,   37,   41,   35,    0,    0,
  211.     0,   47,   36,    0,    0,    0,   45,   43,   84,   44,
  212.     0,   46,    0,    0,    0,    0,    0,   48,    0,    0,
  213.     0,   38,   40,   42,   39,   37,   41,   35,   48,   47,
  214.    36,    0,    0,    0,   45,   43,   85,   44,    0,   46,
  215.    47,   36,    0,    0,    0,   45,   43,    0,   44,    0,
  216.    46,    0,   39,   37,   41,   35,    0,    0,   48,    0,
  217.     0,   96,    0,   39,   37,   41,   35,   47,   36,    0,
  218.     0,  107,   45,   43,    0,   44,    0,   46,    0,    0,
  219.     0,    0,    0,    0,    0,    0,   48,    0,    0,    0,
  220.    39,   37,   41,   35,   47,   36,    0,   48,    0,   45,
  221.    43,  108,   44,    0,   46,   47,   36,    0,    0,    0,
  222.    45,   43,  109,   44,    0,   46,    0,   39,   37,   41,
  223.    35,    0,    0,    0,   48,    0,    0,    0,   39,   37,
  224.    41,   35,    0,   47,   36,    0,    0,    0,   45,   43,
  225.   114,   44,    0,   46,    0,    0,    0,    0,    0,    0,
  226.     0,   48,    0,   38,   40,   42,   39,   37,   41,   35,
  227.    47,   36,   48,    0,    0,   45,   43,  115,   44,    0,
  228.    46,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  229.    38,   40,   42,   39,   37,   41,   35,    0,    0,    0,
  230.    48,   38,   40,   42,    0,    0,    0,    0,    0,    0,
  231.     0,   47,   36,    0,    0,  122,   45,   43,    0,   44,
  232.     0,   46,    0,    0,    0,    0,    0,   48,    0,    0,
  233.     0,   38,   40,   42,   39,   37,   41,   35,    0,   47,
  234.    36,    0,    0,    0,   45,   43,  123,   44,    0,   46,
  235.     0,    0,    0,    0,    0,    0,    0,    0,    0,   38,
  236.    40,   42,   39,   37,   41,   35,    0,    0,   48,    0,
  237.    38,   40,   42,    0,    0,    0,    0,   47,   36,    0,
  238.     0,  124,   45,   43,    0,   44,    0,   46,    0,    0,
  239.     0,    0,    0,    0,    0,    0,   48,   38,   40,   42,
  240.    39,   37,   41,   35,   47,   36,    0,    0,  125,   45,
  241.    43,    0,   44,    0,   46,    0,    0,    0,    0,    0,
  242.     0,    0,    0,    0,   38,   40,   42,   39,   37,   41,
  243.    35,    0,    0,    0,   48,   38,   40,   42,    0,    0,
  244.     0,    0,    0,   47,   36,    0,    0,  126,   45,   43,
  245.     0,   44,    0,   46,    0,    0,    0,    0,    0,    0,
  246.     0,   48,    0,   38,   40,   42,   39,   37,   41,   35,
  247.    47,   36,    0,    0,  127,   45,   43,    0,   44,    0,
  248.    46,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  249.    38,   40,   42,   39,   37,   41,   35,   47,   36,    0,
  250.    48,  129,   45,   43,    0,   44,    0,   46,    0,    0,
  251.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  252.    39,   37,   41,   35,    0,    0,    0,   48,    0,    0,
  253.     0,   38,   40,   42,    0,    0,    0,    0,    0,   47,
  254.    36,    0,    0,    0,   45,   43,    0,   44,    0,   46,
  255.     0,    0,    0,    0,   48,    0,    0,    0,    0,   38,
  256.    40,   42,   39,   37,   41,   35,   47,    0,    0,    0,
  257.     0,   45,   43,    0,   44,    0,   46,   47,    0,    0,
  258.     0,    0,   45,   43,    0,   44,    0,   46,    0,   39,
  259.    37,   41,    0,    0,    0,    0,   48,   38,   40,   42,
  260.    39,    0,   41,    0,    0,    0,    0,    0,    0,    0,
  261.     0,    0,   19,    0,   21,   22,    0,    0,    0,    0,
  262.     0,    0,    0,   48,   38,   40,   42,    0,    0,   34,
  263.     0,    0,    0,    0,   48,    0,   50,   51,   52,   53,
  264.    54,    0,    0,    0,    0,    0,    0,   68,   69,   70,
  265.    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
  266.    81,    0,    0,   38,   40,   42,    0,    0,    0,    0,
  267.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  268.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  269.    38,   40,   42,    0,    0,   97,   98,   99,    0,  100,
  270.     0,    0,  101,  102,  103,  104,    0,    0,  106,    0,
  271.     0,    0,    0,    0,    0,    0,    0,   38,   40,   42,
  272.   116,  117,    0,  118,    0,  119,  120,  121,    0,    0,
  273.     0,    0,    0,    0,    0,  128,    0,    0,    0,    0,
  274.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  275.     0,    0,    0,    0,    0,    0,    0,    0,    0,   38,
  276.    40,   42,    0,    0,    0,    0,    0,    0,    0,    0,
  277.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  278.     0,    0,    0,    0,    0,    0,   38,   40,   42,    0,
  279.     0,    0,    0,    0,    0,    0,    0,    0,   40,   42,
  280. };
  281. short yycheck[] = {                                      33,
  282.     0,   41,   41,   40,   44,   44,   40,  262,  263,   40,
  283.    37,   45,    0,  262,  263,   42,   43,   40,   45,   41,
  284.    47,   41,   44,   41,   44,   40,   44,    0,  262,  263,
  285.    40,   40,   40,   40,   40,   40,   94,   37,   38,    0,
  286.    44,   41,   42,   43,   44,   45,   41,   47,   41,   37,
  287.    38,    0,   41,   41,   42,   43,   44,   45,   58,   47,
  288.    60,   61,   62,   63,   44,   38,    0,   94,   41,   44,
  289.    58,   44,   60,   61,   62,   63,   37,   38,    0,   44,
  290.    41,   42,   43,   44,   45,   58,   47,    0,   37,   38,
  291.    63,    0,   41,   42,   43,   44,   45,   58,   47,   60,
  292.    61,   62,   63,   95,   38,   -1,   -1,   41,   -1,   58,
  293.    44,   60,   61,   62,   63,    0,   38,    0,   -1,   41,
  294.    -1,   43,   44,   45,   58,   38,    0,   61,   41,   63,
  295.    43,   44,   45,    0,   -1,   -1,   58,   -1,   60,   61,
  296.    62,   63,    0,   -1,    0,   58,   -1,   60,   61,   62,
  297.    63,   -1,   -1,   38,   -1,   38,   41,   -1,   41,   44,
  298.    -1,   44,   -1,   -1,   38,   -1,   -1,   41,   -1,   -1,
  299.    44,   38,   -1,   58,   41,   58,   61,   44,   63,   -1,
  300.    63,   -1,   38,   41,   58,   41,   44,   61,   44,   63,
  301.    -1,   58,   33,   37,   61,   -1,   63,   -1,   42,   40,
  302.    58,   -1,   58,   47,   45,   -1,   -1,   63,   33,   -1,
  303.    -1,   -1,   -1,   -1,   -1,   40,   -1,   -1,   -1,   -1,
  304.    45,   -1,  256,   -1,   -1,   -1,   -1,  261,   -1,  263,
  305.   264,  265,  266,  267,  268,  269,  270,  271,  272,  273,
  306.    33,  275,   -1,   -1,   -1,   -1,   -1,   40,   -1,   -1,
  307.    94,   -1,   45,   -1,   -1,   -1,  256,  257,  258,  259,
  308.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,  257,
  309.   258,  259,   -1,   -1,   -1,   -1,   37,   38,   -1,   -1,
  310.    41,   42,   43,  256,   45,   -1,   47,   -1,   -1,   -1,
  311.    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  259,   60,
  312.    61,   62,   63,   -1,   -1,   -1,   -1,  256,  257,  258,
  313.   259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  314.    -1,   -1,  256,  257,   -1,   -1,   -1,   -1,   -1,   -1,
  315.    -1,   -1,   -1,   94,  256,  257,  258,  259,   -1,   -1,
  316.    -1,   -1,   -1,  256,  257,  258,  259,   -1,   -1,   -1,
  317.    -1,   37,   38,   -1,   -1,   41,   42,   43,   44,   45,
  318.    -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  319.    -1,  256,  257,  256,   60,   61,   62,   63,   -1,   -1,
  320.    -1,   -1,  256,  257,   -1,   -1,   -1,   -1,   -1,  256,
  321.   257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
  322.   256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   94,   -1,
  323.    -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,   -1,
  324.   261,   -1,  263,  264,  265,  266,  267,  268,  269,  270,
  325.   271,  272,  273,   -1,  275,   -1,  261,  262,  263,  264,
  326.   265,  266,  267,  268,  269,  270,  271,  272,  273,   -1,
  327.   275,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  328.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  261,   -1,
  329.   263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  330.   273,   -1,  275,   37,   38,   -1,   -1,   41,   42,   43,
  331.    44,   45,   -1,   47,   -1,  256,  257,  258,  259,   -1,
  332.    -1,   -1,   -1,   -1,   -1,   -1,   60,   61,   62,   63,
  333.    37,   38,   -1,   -1,   41,   42,   43,   -1,   45,   -1,
  334.    47,   37,   38,   -1,   -1,   -1,   42,   43,   44,   45,
  335.    -1,   47,   -1,   60,   61,   62,   63,   -1,   -1,   -1,
  336.    94,   -1,   -1,   -1,   60,   61,   62,   63,   -1,   -1,
  337.    -1,   37,   38,   -1,   -1,   -1,   42,   43,   44,   45,
  338.    -1,   47,   -1,   -1,   -1,   -1,   -1,   94,   -1,   -1,
  339.    -1,  257,  258,  259,   60,   61,   62,   63,   94,   37,
  340.    38,   -1,   -1,   -1,   42,   43,   44,   45,   -1,   47,
  341.    37,   38,   -1,   -1,   -1,   42,   43,   -1,   45,   -1,
  342.    47,   -1,   60,   61,   62,   63,   -1,   -1,   94,   -1,
  343.    -1,   58,   -1,   60,   61,   62,   63,   37,   38,   -1,
  344.    -1,   41,   42,   43,   -1,   45,   -1,   47,   -1,   -1,
  345.    -1,   -1,   -1,   -1,   -1,   -1,   94,   -1,   -1,   -1,
  346.    60,   61,   62,   63,   37,   38,   -1,   94,   -1,   42,
  347.    43,   44,   45,   -1,   47,   37,   38,   -1,   -1,   -1,
  348.    42,   43,   44,   45,   -1,   47,   -1,   60,   61,   62,
  349.    63,   -1,   -1,   -1,   94,   -1,   -1,   -1,   60,   61,
  350.    62,   63,   -1,   37,   38,   -1,   -1,   -1,   42,   43,
  351.    44,   45,   -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,
  352.    -1,   94,   -1,  257,  258,  259,   60,   61,   62,   63,
  353.    37,   38,   94,   -1,   -1,   42,   43,   44,   45,   -1,
  354.    47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  355.   257,  258,  259,   60,   61,   62,   63,   -1,   -1,   -1,
  356.    94,  257,  258,  259,   -1,   -1,   -1,   -1,   -1,   -1,
  357.    -1,   37,   38,   -1,   -1,   41,   42,   43,   -1,   45,
  358.    -1,   47,   -1,   -1,   -1,   -1,   -1,   94,   -1,   -1,
  359.    -1,  257,  258,  259,   60,   61,   62,   63,   -1,   37,
  360.    38,   -1,   -1,   -1,   42,   43,   44,   45,   -1,   47,
  361.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
  362.   258,  259,   60,   61,   62,   63,   -1,   -1,   94,   -1,
  363.   257,  258,  259,   -1,   -1,   -1,   -1,   37,   38,   -1,
  364.    -1,   41,   42,   43,   -1,   45,   -1,   47,   -1,   -1,
  365.    -1,   -1,   -1,   -1,   -1,   -1,   94,  257,  258,  259,
  366.    60,   61,   62,   63,   37,   38,   -1,   -1,   41,   42,
  367.    43,   -1,   45,   -1,   47,   -1,   -1,   -1,   -1,   -1,
  368.    -1,   -1,   -1,   -1,  257,  258,  259,   60,   61,   62,
  369.    63,   -1,   -1,   -1,   94,  257,  258,  259,   -1,   -1,
  370.    -1,   -1,   -1,   37,   38,   -1,   -1,   41,   42,   43,
  371.    -1,   45,   -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,
  372.    -1,   94,   -1,  257,  258,  259,   60,   61,   62,   63,
  373.    37,   38,   -1,   -1,   41,   42,   43,   -1,   45,   -1,
  374.    47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  375.   257,  258,  259,   60,   61,   62,   63,   37,   38,   -1,
  376.    94,   41,   42,   43,   -1,   45,   -1,   47,   -1,   -1,
  377.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  378.    60,   61,   62,   63,   -1,   -1,   -1,   94,   -1,   -1,
  379.    -1,  257,  258,  259,   -1,   -1,   -1,   -1,   -1,   37,
  380.    38,   -1,   -1,   -1,   42,   43,   -1,   45,   -1,   47,
  381.    -1,   -1,   -1,   -1,   94,   -1,   -1,   -1,   -1,  257,
  382.   258,  259,   60,   61,   62,   63,   37,   -1,   -1,   -1,
  383.    -1,   42,   43,   -1,   45,   -1,   47,   37,   -1,   -1,
  384.    -1,   -1,   42,   43,   -1,   45,   -1,   47,   -1,   60,
  385.    61,   62,   -1,   -1,   -1,   -1,   94,  257,  258,  259,
  386.    60,   -1,   62,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  387.    -1,   -1,    0,   -1,    2,    3,   -1,   -1,   -1,   -1,
  388.    -1,   -1,   -1,   94,  257,  258,  259,   -1,   -1,   17,
  389.    -1,   -1,   -1,   -1,   94,   -1,   24,   25,   26,   27,
  390.    28,   -1,   -1,   -1,   -1,   -1,   -1,   35,   36,   37,
  391.    38,   39,   40,   41,   42,   43,   44,   45,   46,   47,
  392.    48,   -1,   -1,  257,  258,  259,   -1,   -1,   -1,   -1,
  393.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  394.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  395.   257,  258,  259,   -1,   -1,   83,   84,   85,   -1,   87,
  396.    -1,   -1,   90,   91,   92,   93,   -1,   -1,   96,   -1,
  397.    -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,  258,  259,
  398.   108,  109,   -1,  111,   -1,  113,  114,  115,   -1,   -1,
  399.    -1,   -1,   -1,   -1,   -1,  123,   -1,   -1,   -1,   -1,
  400.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  401.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
  402.   258,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  403.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  404.    -1,   -1,   -1,   -1,   -1,   -1,  257,  258,  259,   -1,
  405.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  258,  259,
  406. };
  407. #define YYFINAL 18
  408. #ifndef YYDEBUG
  409. #define YYDEBUG 0
  410. #endif
  411. #define YYMAXTOKEN 278
  412. #if YYDEBUG
  413. char *yyname[] = {
  414. "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  415. "'!'",0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,
  416. 0,0,0,0,0,"':'",0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  417. 0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  418. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  419. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  420. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  421. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"NE","LE","GE","NEG","L_CELL","L_RANGE","L_VAR",
  422. "L_CONST","L_FN0","L_FN1","L_FN2","L_FN3","L_FN4","L_FNN","L_FN1R","L_FN2R",
  423. "L_FN3R","L_FN4R","L_FNNR","L_LE","L_NE","L_GE",
  424. };
  425. char *yyrule[] = {
  426. "$accept : line",
  427. "line : exp",
  428. "line : error",
  429. "exp : L_CONST",
  430. "exp : cell",
  431. "exp : L_FN0 '(' ')'",
  432. "exp : L_FN1 '(' exp ')'",
  433. "exp : L_FN2 '(' exp ',' exp ')'",
  434. "exp : L_FN3 '(' exp ',' exp ',' exp ')'",
  435. "exp : L_FN4 '(' exp ',' exp ',' exp ',' exp ')'",
  436. "exp : L_FNN '(' exp_list ')'",
  437. "exp : L_FN1R '(' L_RANGE ')'",
  438. "exp : L_FN1R '(' L_VAR ')'",
  439. "exp : L_FN2R '(' L_RANGE ',' exp ')'",
  440. "exp : L_FN2R '(' L_VAR ',' exp ')'",
  441. "exp : L_FN2R '(' L_RANGE ',' exp ',' exp ')'",
  442. "exp : L_FN2R '(' L_VAR ',' exp ',' exp ')'",
  443. "exp : L_FN3R '(' L_RANGE ',' exp ',' exp ')'",
  444. "exp : L_FN3R '(' L_VAR ',' exp ',' exp ')'",
  445. "exp : L_FNNR '(' range_exp_list ')'",
  446. "exp : exp '?' exp ':' exp",
  447. "exp : exp '&' exp",
  448. "exp : exp '<' exp",
  449. "exp : exp LE exp",
  450. "exp : exp '=' exp",
  451. "exp : exp NE exp",
  452. "exp : exp '>' exp",
  453. "exp : exp GE exp",
  454. "exp : exp '+' exp",
  455. "exp : exp '-' exp",
  456. "exp : exp '*' exp",
  457. "exp : exp '/' exp",
  458. "exp : exp '%' exp",
  459. "exp : exp '^' exp",
  460. "exp : '-' exp",
  461. "exp : '!' exp",
  462. "exp : '(' exp ')'",
  463. "exp : '(' exp error",
  464. "exp : '(' error",
  465. "exp_list : exp",
  466. "exp_list : exp_list ',' exp",
  467. "range_exp : L_RANGE",
  468. "range_exp : exp",
  469. "range_exp_list : range_exp",
  470. "range_exp_list : range_exp_list ',' range_exp",
  471. "cell : L_CELL",
  472. "cell : L_VAR",
  473. };
  474. #endif
  475. #ifndef YYSTYPE
  476. typedef int YYSTYPE;
  477. #endif
  478. #define yyclearin (yychar=(-1))
  479. #define yyerrok (yyerrflag=0)
  480. #ifndef YYSTACKSIZE
  481. #ifdef YYMAXDEPTH
  482. #define YYSTACKSIZE YYMAXDEPTH
  483. #else
  484. #define YYSTACKSIZE 300
  485. #endif
  486. #endif
  487. int yydebug;
  488. int yynerrs;
  489. int yyerrflag;
  490. int yychar;
  491. short *yyssp;
  492. YYSTYPE *yyvsp;
  493. YYSTYPE yyval;
  494. YYSTYPE yylval;
  495. #define yystacksize YYSTACKSIZE
  496. short yyss[YYSTACKSIZE];
  497. YYSTYPE yyvs[YYSTACKSIZE];
  498. #line 283 "parse.y"
  499.  
  500. void
  501. yyerror FUN1(char *, s)
  502. {
  503.     if(!parse_error)
  504.         parse_error=PARSE_ERR;
  505. }
  506.  
  507. YYSTYPE
  508. make_list FUN2(YYSTYPE, car, YYSTYPE, cdr)
  509. {
  510.     YYSTYPE ret;
  511.  
  512.     ret=(YYSTYPE)obstack_alloc(&tmp_mem,sizeof(*ret));
  513.     ret->comp_value = 0;
  514.     ret->n_x.v_subs[0]=car;
  515.     ret->n_x.v_subs[1]=cdr;
  516.     return ret;
  517. }
  518.  
  519. #define ERROR -1
  520.  
  521. extern struct node *yylval;
  522.  
  523. #ifdef __STDC__
  524. unsigned char parse_cell_or_range (char **,struct rng *);
  525. int str_to_col (char ** str);
  526. #else
  527. unsigned char parse_cell_or_range ();
  528. #endif
  529.  
  530. int
  531. yylex FUN0()
  532. {
  533.     int ch;
  534.     struct node *new;
  535.     int isflt;
  536.     char *begin;
  537.     char *tmp_str;
  538.     unsigned char byte_value;
  539.     int n;
  540.  
  541.     /* unsigned char *ptr; */
  542.     int nn;
  543.     struct function *fp;
  544.     int tmp_ch;
  545.  
  546. #ifdef TEST
  547.     if(!instr)
  548.         return ERROR;
  549. #endif
  550.     while(isspace(*instr))
  551.         instr++;
  552.     ch = *instr++;
  553.     if(ch=='(' || ch==',' || ch==')')
  554.         return ch;
  555.  
  556.     new=(struct node *)obstack_alloc(&tmp_mem,sizeof(struct node));
  557.     new->add_byte=0;
  558.     new->sub_value=0;
  559.     switch(ch) {
  560.     case 0:
  561.         return 0;
  562.  
  563.     case '0': case '1': case '2': case '3': case '4': case '5': case '6':
  564.     case '7': case '8': case '9': case '.':
  565.         isflt = (ch=='.');
  566.  
  567.         begin=instr-1;
  568.         tmp_str=instr;
  569.  
  570.         while(isdigit(*tmp_str) || (!isflt && *tmp_str=='.' && ++isflt))
  571.             tmp_str++;
  572.         if(*tmp_str=='e' || *tmp_str=='E') {
  573.             isflt=1;
  574.             tmp_str++;
  575.             if(*tmp_str=='-' || *tmp_str=='+')
  576.                 tmp_str++;
  577.             while(isdigit(*tmp_str))
  578.                 tmp_str++;
  579.         }
  580.         if(isflt) {
  581.             new->n_x.v_float=astof((char **)(&begin));
  582.             byte_value=CONST_FLT;
  583.         } else {
  584.             new->n_x.v_int=astol((char **)(&begin));
  585.             if(begin!=tmp_str) {
  586.                 begin=instr-1;
  587.                 new->n_x.v_float=astof((char **)(&begin));
  588.                 byte_value=CONST_FLT;
  589.             } else
  590.                 byte_value=CONST_INT;
  591.         }
  592.         ch=L_CONST;
  593.         instr=begin;
  594.         break;
  595.  
  596.     case '"':
  597.         begin=instr;
  598.         while(*instr && *instr!='"') {
  599.             if(*instr=='\\' && instr[1])
  600.                 instr++;
  601.             instr++;
  602.         }
  603.         if(!*instr) {
  604.             parse_error=NO_QUOTE;
  605.             return ERROR;
  606.         }
  607.         tmp_str=new->n_x.v_string=(char *)ck_malloc(1+instr-begin);
  608.         while(begin!=instr) {
  609.             unsigned char n;
  610.  
  611.             if(*begin=='\\') {
  612.                 begin++;
  613.                 if(begin[0]>='0' && begin[0]<='7') {
  614.                     if(begin[1]>='0' && begin[1]<='7') {
  615.                         if(begin[2]>='0' && begin[2]<='7') {
  616.                             n=(begin[2]-'0') + (010 * (begin[1]-'0')) + ( 0100 * (begin[0]-'0'));
  617.                             begin+=3;
  618.                         } else {
  619.                             n=(begin[1]-'0') + (010 * (begin[0]-'0'));
  620.                             begin+=2;
  621.                         }
  622.                     } else {
  623.                         n=begin[0]-'0';
  624.                         begin++;
  625.                     }
  626.                 } else
  627.                     n= *begin++;
  628.                 *tmp_str++= n;
  629.             } else
  630.                 *tmp_str++= *begin++;
  631.         }
  632.         *tmp_str='\0';
  633.         instr++;
  634.         byte_value=CONST_STR;
  635.         ch=L_CONST;
  636.         break;
  637.  
  638.     case '+':    case '-':
  639.  
  640.     case '*':    case '/':    case '%':    case '&':
  641.     /* case '|': */    case '^':    case '=':
  642.  
  643.     case '?':
  644.     {
  645.         unsigned char *ptr;
  646.  
  647.         for(ptr= fnin;*ptr;ptr++)
  648.             if(the_funs[*ptr].fn_str[0]==ch)
  649.                 break;
  650. #ifdef TEST
  651.         if(!*ptr)
  652.             panic("Can't find fnin[] entry for '%c'",ch);
  653. #endif
  654.         byte_value= *ptr;
  655.     }
  656.         break;
  657.  
  658.     case ':':
  659.         byte_value=IF;
  660.         break;
  661.  
  662.     case '!':
  663.     case '<':
  664.     case '>':
  665.         if(*instr!='=') {
  666.             byte_value = (ch=='<') ? LESS : (ch=='>') ? GREATER : NOT;
  667.             break;
  668.         }
  669.         instr++;
  670.         byte_value = (ch=='<') ? LESSEQ : (ch=='>') ? GREATEQ : NOTEQUAL;
  671.         ch = (ch=='<') ? LE : (ch=='>') ? GE : NE;
  672.         break;
  673.  
  674.     case '\'':
  675.     case ';':
  676.     case '[':
  677.     case '\\':
  678.     case ']':
  679.     case '`':
  680.     case '{':
  681.     case '}':
  682.     case '~':
  683.     bad_chr:
  684.         parse_error=BAD_CHAR;
  685.         return ERROR;
  686.  
  687.     case '#':
  688.         begin=instr-1;
  689.         while(*instr && (isalnum(*instr) || *instr=='_'))
  690.             instr++;
  691.         ch= *instr;
  692.         *instr=0;
  693.         if(!stricmp(begin,tname))
  694.             byte_value=F_TRUE;
  695.         else if(!stricmp(begin,fname))
  696.             byte_value=F_FALSE;
  697.         else if(!stricmp(begin,iname) && (begin[4]==0 || !stricmp(begin+4,"inity")))
  698.             byte_value=CONST_INF;
  699.         else if(!stricmp(begin,mname) ||
  700.             !stricmp(begin,"#ninf"))
  701.             byte_value=CONST_NINF;
  702.         else if(!stricmp(begin,nname) ||
  703.             !stricmp(begin,"#nan"))
  704.             byte_value=CONST_NAN;
  705.         else {
  706.             for(n=1;n<=ERR_MAX;n++)
  707.                 if(!stricmp(begin,ename[n]))
  708.                     break;
  709.             if(n>ERR_MAX)
  710.                 n=BAD_CHAR;
  711.             new->n_x.v_int=n;
  712.             byte_value=CONST_ERR;
  713.         }
  714.         *instr=ch;
  715.         ch=L_CONST;
  716.         break;
  717.  
  718.     default:
  719.         if(!a0 && (ch=='@' || ch=='$'))
  720.            goto bad_chr;
  721.  
  722.         if(a0 && ch=='@') {
  723.             begin=instr;
  724.             while(*instr && (isalpha(*instr) || isdigit(*instr) || *instr=='_'))
  725.                 instr++;
  726.             n=instr-begin;
  727.         } else {
  728.             begin=instr-1;
  729.             byte_value=parse_cell_or_range(&begin,&(new->n_x.v_rng));
  730.             if(byte_value) {
  731.                 if((byte_value& ~0x3)==R_CELL)
  732.                     ch=L_CELL;
  733.                 else
  734.                     ch=L_RANGE;
  735.                 instr=begin;
  736.                 break;
  737.             }
  738.  
  739.             while(*instr && (isalpha(*instr) || isdigit(*instr) || *instr=='_'))
  740.                 instr++;
  741.  
  742.             n=instr-begin;
  743.             while(isspace(*instr))
  744.                 instr++;
  745.  
  746.             if(*instr!='(') {
  747.                 ch=L_VAR;
  748.                 byte_value=VAR;
  749.                 new->n_x.v_var=find_or_make_var(begin,n);
  750.                 break;
  751.             }
  752.         }
  753.         tmp_ch=begin[n];
  754.         begin[n]='\0';
  755.         fp=hash_find(parse_hash,begin);
  756.         begin[n]=tmp_ch;
  757.         byte_value= ERROR;
  758.         if(!fp) {
  759.             parse_error=BAD_FUNC;
  760.             return ERROR;
  761.         }
  762.  
  763.         if(fp>=the_funs && fp<=&the_funs[USR1])
  764.             byte_value=fp-the_funs;
  765.         else {
  766.             for(nn=0;nn<n_usr_funs;nn++) {
  767.                 if(fp>=&usr_funs[nn][0] && fp<=&usr_funs[nn][usr_n_funs[nn]]) {
  768.                     byte_value=USR1+nn;
  769.                     new->sub_value=fp-&usr_funs[nn][0];
  770.                     break;
  771.                 }
  772.             }
  773. #ifdef TEST
  774.             if(nn==n_usr_funs) {
  775.                 io_error_msg("Couln't turn fp into a ##");
  776.                 parse_error=BAD_FUNC;
  777.                 return ERROR;
  778.             }
  779. #endif
  780.         }
  781.  
  782.         if(fp->fn_argn&X_J)
  783.             ch= byte_value==F_IF ? L_FN3 : L_FN2;
  784.         else if(fp->fn_argt[0]=='R' || fp->fn_argt[0]=='E')
  785.             ch=L_FN1R-1+fp->fn_argn-X_A0;
  786.         else
  787.             ch=L_FN0 + fp->fn_argn-X_A0;
  788.  
  789.         break;
  790.     }
  791.     /* new->node_type=ch; */
  792.     new->comp_value=byte_value;
  793.     yylval=new;
  794.     return ch;
  795. }
  796.  
  797. /* Return value is
  798.     0 if it doesn't look like a cell or a range,
  799.     R_CELL if it is a cell (ptr now points past the characters, lr and lc hold the row and col of the cell)
  800.     RANGE if it is a range (ptr points past the chars)
  801.  */
  802. unsigned char
  803. parse_cell_or_range FUN2(char **,ptr, struct rng *,retp)
  804. {
  805.     if(a0) {
  806.         unsigned tmpc,tmpr;
  807.         char *p;
  808.         int abz = ROWREL|COLREL;
  809.  
  810.         p= *ptr;
  811.         tmpc=0;
  812.         if(*p=='$') {
  813.             abz-=COLREL;
  814.             p++;
  815.         }
  816.         if(!isalpha(*p))
  817.             return 0;
  818.         tmpc=str_to_col(&p);
  819.         if(tmpc<MIN_COL || tmpc>MAX_COL)
  820.             return 0;
  821.         if(*p=='$') {
  822.             abz-=ROWREL;
  823.             p++;
  824.         }
  825.         if(!isdigit(*p))
  826.             return 0;
  827.         for(tmpr=0;isdigit(*p);p++)
  828.             tmpr=tmpr*10 + *p - '0';
  829.  
  830.         if(tmpr<MIN_ROW || tmpr>MAX_ROW)
  831.             return 0;
  832.  
  833.         if(*p==':' || *p=='.') {
  834.             unsigned tmpc1,tmpr1;
  835.  
  836.             abz = ((abz&COLREL) ? LCREL : 0)|((abz&ROWREL) ? LRREL : 0)|HRREL|HCREL;
  837.             p++;
  838.             if(*p=='$') {
  839.                 abz-=HCREL;
  840.                 p++;
  841.             }
  842.             if(!isalpha(*p))
  843.                 return 0;
  844.             tmpc1=str_to_col(&p);
  845.             if(tmpc1<MIN_COL || tmpc1>MAX_COL)
  846.                 return 0;
  847.             if(*p=='$') {
  848.                 abz-=HRREL;
  849.                 p++;
  850.             }
  851.             if(!isdigit(*p))
  852.                 return 0;
  853.             for(tmpr1=0;isdigit(*p);p++)
  854.                 tmpr1=tmpr1*10 + *p - '0';
  855.             if(tmpr1<MIN_ROW || tmpr1>MAX_ROW)
  856.                 return 0;
  857.  
  858.             if(tmpr<tmpr1) {
  859.                 retp->lr=tmpr;
  860.                 retp->hr=tmpr1;
  861.             } else {
  862.                 retp->lr=tmpr1;
  863.                 retp->hr=tmpr;
  864.             }
  865.             if(tmpc<tmpc1) {
  866.                 retp->lc=tmpc;
  867.                 retp->hc=tmpc1;
  868.             } else {
  869.                 retp->lc=tmpc1;
  870.                 retp->hc=tmpc;
  871.             }
  872.             *ptr= p;
  873.             return RANGE | abz;
  874.         }
  875.         retp->lr = retp->hr = tmpr;
  876.         retp->lc = retp->hc = tmpc;
  877.         *ptr=p;
  878.         return R_CELL | abz;
  879.     } else {
  880.         char *p;
  881.         unsigned char retr;
  882.         unsigned char retc;
  883.         int ended;
  884.         long num;
  885.         CELLREF tmp;
  886.  
  887. #define CK_ABS_R(x)    ((x)<MIN_ROW || (x)>MAX_ROW)
  888.  
  889. #define CK_REL_R(x)    (((x)>0 && MAX_ROW-(x)<cur_row) \
  890.              || ((x)<0 && MIN_ROW-(x)>cur_row)) 
  891.  
  892. #define CK_ABS_C(x)    ((x)<MIN_COL || (x)>MAX_COL)
  893.  
  894. #define CK_REL_C(x)    (((x)>0 && MAX_COL-(x)<cur_col)    \
  895.              || ((x)<0 && MIN_COL-(x)>cur_col))
  896.  
  897. #define MAYBEREL(p) (*(p)=='[' && (isdigit((p)[1]) || (((p)[1]=='+' || (p)[1]=='-') && isdigit((p)[2]))))
  898.  
  899.         p= *ptr;
  900.         retr=0;
  901.         retc=0;
  902.         ended=0;
  903.         while(ended==0) {
  904.             switch(*p) {
  905.             case 'r':
  906.             case 'R':
  907.                 if(retr) {
  908.                     ended++;
  909.                     break;
  910.                 }
  911.                 p++;
  912.                 retr=R_CELL;
  913.                 if(isdigit(*p)) {
  914.                     num=astol(&p);
  915.                     if (CK_ABS_R(num))
  916.                       return 0;
  917.                     retp->lr= retp->hr=num;
  918.                 } else if(MAYBEREL(p)) {
  919.                     p++;
  920.                     num=astol(&p);
  921.                     if (CK_REL_R(num))
  922.                       return 0;
  923.                     retp->lr= retp->hr=num+cur_row;
  924.                     retr|=ROWREL;
  925.                     if(*p==':') {
  926.                         retr=RANGE|LRREL|HRREL;
  927.                         p++;
  928.                         num=astol(&p);
  929.                         if (CK_REL_R(num))
  930.                           return 0;
  931.                         retp->hr=num+cur_row;
  932.                     }
  933.                     if(*p++!=']')
  934.                         return 0;
  935.                 } else if(retc || *p=='c' || *p=='C') {
  936.                     retr|=ROWREL;
  937.                     retp->lr= retp->hr=cur_row;
  938.                 } else
  939.                     return 0;
  940.                 if(*p==':' && retr!=(RANGE|LRREL|HRREL)) {
  941.                     retr= (retr&ROWREL) ? RANGE|LRREL : RANGE;
  942.                     p++;
  943.                     if(isdigit(*p)) {
  944.                         num=astol(&p);
  945.                         if (CK_ABS_R(num))
  946.                           return 0;
  947.                          retp->hr=num;
  948.                     } else if(MAYBEREL(p)) {
  949.                         p++;
  950.                         num=astol(&p);
  951.                         if (CK_REL_R(num))
  952.                           return 0;
  953.                         retp->hr=num+cur_row;
  954.                         retr|=HRREL;
  955.                         if(*p++!=']')
  956.                             return 0;
  957.                     } else
  958.                         return 0;
  959.                 }
  960.  
  961.                 if(retc)
  962.                     ended++;
  963.                 break;
  964.  
  965.             case 'c':
  966.             case 'C':
  967.                 if(retc) {
  968.                     ended++;
  969.                     break;
  970.                 }
  971.                 p++;
  972.                 retc=R_CELL;
  973.                 if(isdigit(*p)) {
  974.                     num=astol(&p);
  975.                     if (CK_ABS_C(num))
  976.                       return 0;
  977.                     retp->lc= retp->hc=num;
  978.                 } else if(MAYBEREL(p)) {
  979.                     p++;
  980.                     num=astol(&p);
  981.                     if (CK_REL_C(num))
  982.                       return 0;
  983.                     retp->lc= retp->hc=num+cur_col;
  984.                     retc|=COLREL;
  985.                     if(*p==':') {
  986.                         retc=RANGE|LCREL|HCREL;
  987.                         p++;
  988.                         num=astol(&p);
  989.                         if (CK_REL_C(num))
  990.                           return 0;
  991.                         retp->hc=num+cur_col;
  992.                     }
  993.                     if(*p++!=']')
  994.                         return 0;
  995.                 } else if(retr || *p=='r' || *p=='R') {
  996.                     retc|=COLREL;
  997.                     retp->lc= retp->hc=cur_col;
  998.                 } else
  999.                     return 0;
  1000.                 if(*p==':' && retc!=(RANGE|LCREL|HCREL)) {
  1001.                     retc= (retc&COLREL) ? RANGE|LCREL : RANGE;
  1002.                     p++;
  1003.                     if(isdigit(*p)) {
  1004.                         num=astol(&p);
  1005.                         if (CK_ABS_C(num))
  1006.                           return 0;
  1007.                          retp->hc=num;
  1008.                     } else if(MAYBEREL(p)) {
  1009.                         p++;
  1010.                         num=astol(&p);
  1011.                         if (CK_REL_C(num))
  1012.                           return 0;
  1013.                         retp->hc=num+cur_col;
  1014.                         retc|=HCREL;
  1015.                         if(*p++!=']')
  1016.                             return 0;
  1017.                     } else
  1018.                         return 0;
  1019.                 }
  1020.  
  1021.                 if(retr)
  1022.                     ended++;
  1023.                 break;
  1024.             default:
  1025.                 if(retr) {
  1026.                     *ptr=p;
  1027.                     retp->lc=MIN_COL;
  1028.                     retp->hc=MAX_COL;
  1029.                     if((retr|ROWREL)==(R_CELL|ROWREL))
  1030.                         return (retr&ROWREL) ? (RANGE|LRREL|HRREL) : RANGE;
  1031.                     else
  1032.                         return retr;
  1033.                 } else if(retc) {
  1034.                     *ptr=p;
  1035.                     retp->lr=MIN_ROW;
  1036.                     retp->hr=MAX_COL;
  1037.                     if((retc|COLREL)==(R_CELL|COLREL))
  1038.                         return (retc&COLREL) ? (RANGE|LCREL|HCREL) : RANGE;
  1039.                     else
  1040.                         return retc;
  1041.                 }
  1042.                 return 0;
  1043.             }
  1044.         }
  1045.         if(!retr || !retc)
  1046.             return 0;
  1047.         *ptr=p;
  1048.         if(retp->lr>retp->hr)
  1049.             tmp=retp->lr,retp->lr=retp->hr,retp->hr=tmp;
  1050.         if(retp->lc>retp->hc)
  1051.             tmp=retp->lc,retp->lc=retp->hc,retp->hc=tmp;
  1052.  
  1053.         if((retr|ROWREL)==(R_CELL|ROWREL)) {
  1054.             if((retc|COLREL)==(R_CELL|COLREL))
  1055.                 return retr|retc;
  1056.             return (retr&ROWREL) ? (retc|LRREL|HRREL) : retc;
  1057.         }
  1058.         if((retc|COLREL)==(R_CELL|COLREL))
  1059.             return (retc&COLREL) ? (retr|LCREL|HCREL) : retr;
  1060.         return retr|retc;
  1061.     }
  1062. }
  1063.  
  1064. int
  1065. str_to_col FUN1(char **,str)
  1066. {
  1067.     int ret;
  1068.     char c,cc,ccc;
  1069. #if MAX_COL>702
  1070.     char cccc;
  1071. #endif
  1072.  
  1073.     ret=0;
  1074.     c=str[0][0];
  1075.     if(!isalpha((cc=str[0][1]))) {
  1076.         (*str)++;
  1077.         return MIN_COL + (isupper(c) ? c-'A' : c-'a');
  1078.     }
  1079.     if(!isalpha((ccc=str[0][2]))) {
  1080.         (*str)+=2;
  1081.         return MIN_COL+26 + (isupper(c) ? c-'A' : c-'a')*26 + (isupper(cc) ? cc-'A' : cc-'a');
  1082.     }
  1083. #if MAX_COL>702
  1084.     if(!isalpha((cccc=str[0][3]))) {
  1085.         (*str)+=3;
  1086.         return MIN_COL+702 + (isupper(c) ? c-'A' : c-'a')*26*26 + (isupper(cc) ? cc-'A' : cc-'a')*26 + (isupper(ccc) ? ccc-'A' : ccc-'a');
  1087.     }
  1088.     if(!isalpha(str[0][4])) {
  1089.         (*str)+=4;
  1090.         return MIN_COL+18278 + (isupper(c) ? c-'A' : c-'a')*26*26*26 + (isupper(cc) ? cc-'A' : cc-'a')*26*26 + (isupper(ccc) ? ccc-'A' : ccc-'a')*26 + (isupper(cccc) ? cccc-'A' : cccc-'a');
  1091.     }
  1092. #endif
  1093.     return 0;
  1094. }
  1095. #line 1096 "y.tab.c"
  1096. #define YYABORT goto yyabort
  1097. #define YYACCEPT goto yyaccept
  1098. #define YYERROR goto yyerrlab
  1099. int
  1100. yyparse()
  1101. {
  1102.     register int yym, yyn, yystate;
  1103. #if YYDEBUG
  1104.     register char *yys;
  1105.     extern char *getenv();
  1106.  
  1107.     if (yys = getenv("YYDEBUG"))
  1108.     {
  1109.         yyn = *yys;
  1110.         if (yyn >= '0' && yyn <= '9')
  1111.             yydebug = yyn - '0';
  1112.     }
  1113. #endif
  1114.  
  1115.     yynerrs = 0;
  1116.     yyerrflag = 0;
  1117.     yychar = (-1);
  1118.  
  1119.     yyssp = yyss;
  1120.     yyvsp = yyvs;
  1121.     *yyssp = yystate = 0;
  1122.  
  1123. yyloop:
  1124.     if (yyn = yydefred[yystate]) goto yyreduce;
  1125.     if (yychar < 0)
  1126.     {
  1127.         if ((yychar = yylex()) < 0) yychar = 0;
  1128. #if YYDEBUG
  1129.         if (yydebug)
  1130.         {
  1131.             yys = 0;
  1132.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  1133.             if (!yys) yys = "illegal-symbol";
  1134.             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  1135.                     yychar, yys);
  1136.         }
  1137. #endif
  1138.     }
  1139.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  1140.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  1141.     {
  1142. #if YYDEBUG
  1143.         if (yydebug)
  1144.             printf("yydebug: state %d, shifting to state %d\n",
  1145.                     yystate, yytable[yyn]);
  1146. #endif
  1147.         if (yyssp >= yyss + yystacksize - 1)
  1148.         {
  1149.             goto yyoverflow;
  1150.         }
  1151.         *++yyssp = yystate = yytable[yyn];
  1152.         *++yyvsp = yylval;
  1153.         yychar = (-1);
  1154.         if (yyerrflag > 0)  --yyerrflag;
  1155.         goto yyloop;
  1156.     }
  1157.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  1158.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  1159.     {
  1160.         yyn = yytable[yyn];
  1161.         goto yyreduce;
  1162.     }
  1163.     if (yyerrflag) goto yyinrecovery;
  1164. #ifdef lint
  1165.     goto yynewerror;
  1166. #endif
  1167. yynewerror:
  1168.     yyerror("syntax error");
  1169. #ifdef lint
  1170.     goto yyerrlab;
  1171. #endif
  1172. yyerrlab:
  1173.     ++yynerrs;
  1174. yyinrecovery:
  1175.     if (yyerrflag < 3)
  1176.     {
  1177.         yyerrflag = 3;
  1178.         for (;;)
  1179.         {
  1180.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  1181.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  1182.             {
  1183. #if YYDEBUG
  1184.                 if (yydebug)
  1185.                     printf("yydebug: state %d, error recovery shifting\
  1186.  to state %d\n", *yyssp, yytable[yyn]);
  1187. #endif
  1188.                 if (yyssp >= yyss + yystacksize - 1)
  1189.                 {
  1190.                     goto yyoverflow;
  1191.                 }
  1192.                 *++yyssp = yystate = yytable[yyn];
  1193.                 *++yyvsp = yylval;
  1194.                 goto yyloop;
  1195.             }
  1196.             else
  1197.             {
  1198. #if YYDEBUG
  1199.                 if (yydebug)
  1200.                     printf("yydebug: error recovery discarding state %d\n",
  1201.                             *yyssp);
  1202. #endif
  1203.                 if (yyssp <= yyss) goto yyabort;
  1204.                 --yyssp;
  1205.                 --yyvsp;
  1206.             }
  1207.         }
  1208.     }
  1209.     else
  1210.     {
  1211.         if (yychar == 0) goto yyabort;
  1212. #if YYDEBUG
  1213.         if (yydebug)
  1214.         {
  1215.             yys = 0;
  1216.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  1217.             if (!yys) yys = "illegal-symbol";
  1218.             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  1219.                     yystate, yychar, yys);
  1220.         }
  1221. #endif
  1222.         yychar = (-1);
  1223.         goto yyloop;
  1224.     }
  1225. yyreduce:
  1226. #if YYDEBUG
  1227.     if (yydebug)
  1228.         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  1229.                 yystate, yyn, yyrule[yyn]);
  1230. #endif
  1231.     yym = yylen[yyn];
  1232.     yyval = yyvsp[1-yym];
  1233.     switch (yyn)
  1234.     {
  1235. case 1:
  1236. #line 87 "parse.y"
  1237. { parse_return=yyvsp[0]; }
  1238. break;
  1239. case 2:
  1240. #line 88 "parse.y"
  1241. {
  1242.         if(!parse_error)
  1243.             parse_error=PARSE_ERR;
  1244.         parse_return=0; }
  1245. break;
  1246. case 5:
  1247. #line 96 "parse.y"
  1248. {
  1249.         yyval=yyvsp[-2]; }
  1250. break;
  1251. case 6:
  1252. #line 98 "parse.y"
  1253. {
  1254.         (yyvsp[-3])->n_x.v_subs[0]=yyvsp[-1];
  1255.         (yyvsp[-3])->n_x.v_subs[1]=(struct node *)0;
  1256.         yyval=yyvsp[-3]; }
  1257. break;
  1258. case 7:
  1259. #line 102 "parse.y"
  1260. {
  1261.         (yyvsp[-5])->n_x.v_subs[0]=yyvsp[-3];
  1262.         (yyvsp[-5])->n_x.v_subs[1]=yyvsp[-1];
  1263.         yyval=yyvsp[-5]; }
  1264. break;
  1265. case 8:
  1266. #line 106 "parse.y"
  1267. {
  1268.         (yyvsp[-7])->n_x.v_subs[0]=make_list(yyvsp[-5],yyvsp[-3]);
  1269.          (yyvsp[-7])->n_x.v_subs[1]=yyvsp[-1];
  1270.          yyval=yyvsp[-7];}
  1271. break;
  1272. case 9:
  1273. #line 110 "parse.y"
  1274. {
  1275.         (yyvsp[-9])->n_x.v_subs[0]=make_list(yyvsp[-7],yyvsp[-5]);
  1276.          (yyvsp[-9])->n_x.v_subs[1]=make_list(yyvsp[-3],yyvsp[-1]);
  1277.          yyval=yyvsp[-9];}
  1278. break;
  1279. case 10:
  1280. #line 114 "parse.y"
  1281. {
  1282.         (yyvsp[-3])->n_x.v_subs[0]=(struct node *)0;
  1283.         (yyvsp[-3])->n_x.v_subs[1]=yyvsp[-1];
  1284.         yyval=yyvsp[-3]; }
  1285. break;
  1286. case 11:
  1287. #line 118 "parse.y"
  1288. {
  1289.         yyvsp[-3]->n_x.v_subs[0]=yyvsp[-1];
  1290.         yyval=yyvsp[-3]; }
  1291. break;
  1292. case 12:
  1293. #line 121 "parse.y"
  1294. {
  1295.         yyvsp[-3]->n_x.v_subs[0]=yyvsp[-1];
  1296.         yyval=yyvsp[-3]; }
  1297. break;
  1298. case 13:
  1299. #line 125 "parse.y"
  1300. {
  1301.         yyvsp[-5]->n_x.v_subs[0]=yyvsp[-3];
  1302.         yyvsp[-5]->n_x.v_subs[1]=yyvsp[-1];
  1303.         yyval=yyvsp[-5]; }
  1304. break;
  1305. case 14:
  1306. #line 129 "parse.y"
  1307. {
  1308.         yyvsp[-5]->n_x.v_subs[0]=yyvsp[-3];
  1309.         yyvsp[-5]->n_x.v_subs[1]=yyvsp[-1];
  1310.         yyval=yyvsp[-5]; }
  1311. break;
  1312. case 15:
  1313. #line 135 "parse.y"
  1314. {
  1315.         if(yyvsp[-7]->comp_value!=F_INDEX)
  1316.             parse_error=PARSE_ERR;
  1317.         yyvsp[-7]->comp_value=F_INDEX2;
  1318.         yyvsp[-7]->n_x.v_subs[0]=make_list(yyvsp[-5],yyvsp[-3]);
  1319.         yyvsp[-7]->n_x.v_subs[1]=yyvsp[-1];
  1320.         yyval=yyvsp[-7]; }
  1321. break;
  1322. case 16:
  1323. #line 142 "parse.y"
  1324. {
  1325.         if(yyvsp[-7]->comp_value!=F_INDEX)
  1326.             parse_error=PARSE_ERR;
  1327.         yyvsp[-7]->comp_value=F_INDEX2;
  1328.         yyvsp[-7]->n_x.v_subs[0]=make_list(yyvsp[-5],yyvsp[-3]);
  1329.         yyvsp[-7]->n_x.v_subs[1]=yyvsp[-1];
  1330.         yyval=yyvsp[-7]; }
  1331. break;
  1332. case 17:
  1333. #line 150 "parse.y"
  1334. {
  1335.         (yyvsp[-7])->n_x.v_subs[0]=make_list(yyvsp[-5],yyvsp[-3]);
  1336.          (yyvsp[-7])->n_x.v_subs[1]=yyvsp[-1];
  1337.          yyval=yyvsp[-7];}
  1338. break;
  1339. case 18:
  1340. #line 154 "parse.y"
  1341. {
  1342.         (yyvsp[-7])->n_x.v_subs[0]=make_list(yyvsp[-5],yyvsp[-3]);
  1343.          (yyvsp[-7])->n_x.v_subs[1]=yyvsp[-1];
  1344.          yyval=yyvsp[-7];}
  1345. break;
  1346. case 19:
  1347. #line 159 "parse.y"
  1348. {
  1349.         (yyvsp[-3])->n_x.v_subs[0]=(struct node *)0;
  1350.         (yyvsp[-3])->n_x.v_subs[1]=yyvsp[-1];
  1351.         yyval=yyvsp[-3]; }
  1352. break;
  1353. case 20:
  1354. #line 163 "parse.y"
  1355. {
  1356.         yyvsp[-3]->comp_value=IF;
  1357.         yyvsp[-3]->n_x.v_subs[0]=yyvsp[-1];
  1358.         yyvsp[-3]->n_x.v_subs[1]=yyvsp[0];
  1359.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-4];
  1360.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[-2];
  1361.         yyval=yyvsp[-3]; }
  1362. break;
  1363. case 21:
  1364. #line 174 "parse.y"
  1365. {
  1366.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1367.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1368.         yyval = yyvsp[-1]; }
  1369. break;
  1370. case 22:
  1371. #line 178 "parse.y"
  1372. {
  1373.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1374.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1375.         yyval = yyvsp[-1]; }
  1376. break;
  1377. case 23:
  1378. #line 182 "parse.y"
  1379. {
  1380.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1381.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1382.         yyval = yyvsp[-1]; }
  1383. break;
  1384. case 24:
  1385. #line 186 "parse.y"
  1386. {
  1387.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1388.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1389.         yyval = yyvsp[-1]; }
  1390. break;
  1391. case 25:
  1392. #line 190 "parse.y"
  1393. {
  1394.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1395.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1396.         yyval = yyvsp[-1]; }
  1397. break;
  1398. case 26:
  1399. #line 194 "parse.y"
  1400. {
  1401.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1402.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1403.         yyval = yyvsp[-1]; }
  1404. break;
  1405. case 27:
  1406. #line 198 "parse.y"
  1407. {
  1408.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1409.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1410.         yyval = yyvsp[-1]; }
  1411. break;
  1412. case 28:
  1413. #line 202 "parse.y"
  1414. {
  1415.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1416.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1417.         yyval = yyvsp[-1]; }
  1418. break;
  1419. case 29:
  1420. #line 206 "parse.y"
  1421. {
  1422.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1423.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1424.         yyval = yyvsp[-1]; }
  1425. break;
  1426. case 30:
  1427. #line 210 "parse.y"
  1428. {
  1429.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1430.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1431.         yyval = yyvsp[-1]; }
  1432. break;
  1433. case 31:
  1434. #line 214 "parse.y"
  1435. {
  1436.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1437.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1438.         yyval = yyvsp[-1]; }
  1439. break;
  1440. case 32:
  1441. #line 218 "parse.y"
  1442. {
  1443.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1444.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1445.         yyval = yyvsp[-1]; }
  1446. break;
  1447. case 33:
  1448. #line 222 "parse.y"
  1449. {
  1450.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[-2];
  1451.         yyvsp[-1]->n_x.v_subs[1]=yyvsp[0];
  1452.         yyval = yyvsp[-1]; }
  1453. break;
  1454. case 34:
  1455. #line 226 "parse.y"
  1456. {
  1457.         if(yyvsp[0]->comp_value==CONST_FLT) {
  1458.             yyvsp[0]->n_x.v_float= -(yyvsp[0]->n_x.v_float);
  1459.             /* free($1); */
  1460.             yyval=yyvsp[0];
  1461.         } else if(yyvsp[0]->comp_value==CONST_INT) {
  1462.             yyvsp[0]->n_x.v_int= -(yyvsp[0]->n_x.v_int);
  1463.             /* free($1); */
  1464.             yyval=yyvsp[0];
  1465.         } else {
  1466.             yyvsp[-1]->comp_value = NEGATE;
  1467.             yyvsp[-1]->n_x.v_subs[0]=yyvsp[0];
  1468.             yyvsp[-1]->n_x.v_subs[1]=(struct node *)0;
  1469.             yyval = yyvsp[-1];
  1470.         } }
  1471. break;
  1472. case 35:
  1473. #line 241 "parse.y"
  1474. {
  1475.         yyvsp[-1]->n_x.v_subs[0]=yyvsp[0];
  1476.         yyvsp[-1]->n_x.v_subs[1]=(struct node *)0;
  1477.         yyval = yyvsp[-1]; }
  1478. break;
  1479. case 36:
  1480. #line 246 "parse.y"
  1481. { yyval = yyvsp[-1]; }
  1482. break;
  1483. case 37:
  1484. #line 247 "parse.y"
  1485. {
  1486.         if(!parse_error)
  1487.             parse_error=NO_CLOSE;
  1488.         }
  1489. break;
  1490. case 38:
  1491. #line 255 "parse.y"
  1492. {
  1493.         if(!parse_error)
  1494.             parse_error=NO_CLOSE;
  1495.         }
  1496. break;
  1497. case 39:
  1498. #line 263 "parse.y"
  1499. { yyval = make_list(yyvsp[0], 0); }
  1500. break;
  1501. case 40:
  1502. #line 265 "parse.y"
  1503. { yyval = make_list(yyvsp[0], yyvsp[-2]); }
  1504. break;
  1505. case 43:
  1506. #line 273 "parse.y"
  1507. { yyval=make_list(yyvsp[0], 0); }
  1508. break;
  1509. case 44:
  1510. #line 275 "parse.y"
  1511. { yyval=make_list(yyvsp[0],yyvsp[-2]); }
  1512. break;
  1513. case 45:
  1514. #line 279 "parse.y"
  1515. { yyval=yyvsp[0]; }
  1516. break;
  1517. #line 1518 "y.tab.c"
  1518.     }
  1519.     yyssp -= yym;
  1520.     yystate = *yyssp;
  1521.     yyvsp -= yym;
  1522.     yym = yylhs[yyn];
  1523.     if (yystate == 0 && yym == 0)
  1524.     {
  1525. #if YYDEBUG
  1526.         if (yydebug)
  1527.             printf("yydebug: after reduction, shifting from state 0 to\
  1528.  state %d\n", YYFINAL);
  1529. #endif
  1530.         yystate = YYFINAL;
  1531.         *++yyssp = YYFINAL;
  1532.         *++yyvsp = yyval;
  1533.         if (yychar < 0)
  1534.         {
  1535.             if ((yychar = yylex()) < 0) yychar = 0;
  1536. #if YYDEBUG
  1537.             if (yydebug)
  1538.             {
  1539.                 yys = 0;
  1540.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  1541.                 if (!yys) yys = "illegal-symbol";
  1542.                 printf("yydebug: state %d, reading %d (%s)\n",
  1543.                         YYFINAL, yychar, yys);
  1544.             }
  1545. #endif
  1546.         }
  1547.         if (yychar == 0) goto yyaccept;
  1548.         goto yyloop;
  1549.     }
  1550.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  1551.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  1552.         yystate = yytable[yyn];
  1553.     else
  1554.         yystate = yydgoto[yym];
  1555. #if YYDEBUG
  1556.     if (yydebug)
  1557.         printf("yydebug: after reduction, shifting from state %d \
  1558. to state %d\n", *yyssp, yystate);
  1559. #endif
  1560.     if (yyssp >= yyss + yystacksize - 1)
  1561.     {
  1562.         goto yyoverflow;
  1563.     }
  1564.     *++yyssp = yystate;
  1565.     *++yyvsp = yyval;
  1566.     goto yyloop;
  1567. yyoverflow:
  1568.     yyerror("yacc stack overflow");
  1569. yyabort:
  1570.     return (1);
  1571. yyaccept:
  1572.     return (0);
  1573. }
  1574.